// 监听来自弹出窗口的消息
chrome.runtime.onMessage.addListener((request, sender, sendResponse) => {
  if (request.action === 'scrapeMenu') {
    console.log('开始抓取菜单数据...');

    // 创建一个响应对象，用于在异步操作完成后发送
    let responseFunction = sendResponse;

    // 执行抓取操作
    scrapeMenuData()
      .then((menuData) => {
        console.log(
          '抓取完成，数据长度:',
          menuData.dishes_series.length,
          menuData.dishes_list.length
        );
        responseFunction({ success: true, data: menuData });
      })
      .catch((error) => {
        console.error('抓取失败:', error);
        responseFunction({
          success: false,
          error: error.message || '未知错误',
        });
      });

    return true; // 保持消息通道开放，以便异步响应
  }
});

// 主要的数据抓取函数
async function scrapeMenuData() {
  console.log('开始执行抓取函数...');

  // 创建结果对象
  const result = {
    dishes_series: [],
    dishes_list: [],
  };

  try {
    // 首先检查页面是否已加载完成
    if (document.readyState !== 'complete') {
      console.log('页面尚未加载完成，等待...');
      await new Promise((resolve) => {
        window.addEventListener('load', resolve);
        // 如果已经加载完成，则立即解析
        if (document.readyState === 'complete') {
          resolve();
        }
      });
    }

    console.log('页面已加载完成，开始抓取数据...');

    // 针对实际Imperial Dragon网站的选择器
    // 菜系有两个可能的来源:
    // 1. 从h2标题获取
    // 2. 从data-category-name属性获取
    const categorySelectors = [
      // h2标题
      'h2.eds-display-text-title-m',
      // 带有category属性的元素
      '[data-category-name]',
    ];

    let categoryElements = [];

    // 尝试从h2标题获取菜系
    const h2Categories = Array.from(
      document.querySelectorAll(categorySelectors[0])
    );
    console.log(`从h2标题找到 ${h2Categories.length} 个菜系元素`);

    if (h2Categories.length > 0) {
      categoryElements = h2Categories;
    } else {
      // 如果h2标题没找到，尝试从data-category-name属性获取
      const categoryAttrs = document.querySelectorAll(categorySelectors[1]);
      console.log(
        `从data-category-name属性找到 ${categoryAttrs.length} 个菜系元素`
      );

      if (categoryAttrs.length > 0) {
        // 去重，因为可能有多个元素具有相同的category-name
        const categoryNames = new Set();
        categoryAttrs.forEach((el) => {
          categoryNames.add(el.getAttribute('data-category-name'));
        });

        categoryElements = Array.from(categoryNames).map((name) => {
          return { textContent: name };
        });
      }
    }

    if (categoryElements.length === 0) {
      console.error('无法找到菜系元素，尝试从其他区域获取...');

      // 尝试从菜单导航中找到菜系
      const menuNavItems = document.querySelectorAll('.eds_list-item');
      if (menuNavItems.length > 0) {
        console.log(`从导航找到 ${menuNavItems.length} 个可能的菜系`);
        categoryElements = Array.from(menuNavItems)
          .filter((item) => {
            // 排除主菜单标题，只保留具体菜系
            const text = item.textContent.trim();
            return text !== 'Main Menu' && text !== 'Lunch Menu';
          })
          .map((item) => {
            return { textContent: item.textContent.split(' ')[0].trim() };
          });
      }
    }

    console.log(`找到 ${categoryElements.length} 个菜系`);

    // 处理菜系
    let categoryIndex = 0;
    for (const categoryElement of categoryElements) {
      const categoryName = categoryElement.textContent?.trim() || '';
      if (
        !categoryName ||
        categoryName.includes('Main Menu') ||
        categoryName.includes('Lunch Menu')
      ) {
        console.log(`跳过菜系: ${categoryName}`);
        continue;
      }

      console.log(`处理菜系: ${categoryName}`);

      // 创建菜系对象
      const category = {
        index: categoryIndex,
        name: categoryName,
        description: '',
        monday: '',
        tuesday: '',
        wednesday: '',
        thursday: '',
        friday: '',
        saturday: '',
        sunday: '',
      };

      // 检查是否有时间限制信息（例如午餐菜单）
      if (categoryName.includes('Lunch')) {
        const timeSchedule = [{ start: '11:00', end: '15:00' }];
        category.monday = timeSchedule;
        category.tuesday = timeSchedule;
        category.wednesday = timeSchedule;
        category.thursday = timeSchedule;
        category.friday = timeSchedule;
        category.saturday = timeSchedule;
        category.sunday = timeSchedule;
      }

      result.dishes_series.push(category);
      categoryIndex++;
    }

    console.log(`成功添加 ${result.dishes_series.length} 个菜系`);

    // 抓取菜品信息
    // 在Imperial Dragon网站中，菜品被组织为li元素
    // 每个菜品具有特定的类名，如"menuItem_1049145"
    const menuItems = document.querySelectorAll('li[class^="menuItem_"]');
    console.log(`找到 ${menuItems.length} 个菜品元素`);

    for (const item of menuItems) {
      // 获取菜系ID
      const itemLink = item.querySelector('a');
      let categoryId = '';
      let categoryName = '';

      if (itemLink) {
        categoryId = itemLink.getAttribute('data-category-id');

        // 从categoryId查找对应的categoryName
        const categoryElement = document.querySelector(
          `[data-category-id="${categoryId}"][data-category-name]`
        );
        if (categoryElement) {
          categoryName = categoryElement.getAttribute('data-category-name');
        }
      }

      // 如果没找到categoryName，使用父级区域的h2标题
      if (!categoryName) {
        let section = item.closest('section') || item.parentElement;
        while (section && !section.querySelector('h2')) {
          section = section.parentElement;
        }

        if (section) {
          const h2 = section.querySelector('h2');
          if (h2) {
            categoryName = h2.textContent.trim();
          }
        }
      }

      // 如果仍然没找到，使用第一个匹配的菜系
      if (!categoryName && result.dishes_series.length > 0) {
        categoryName = result.dishes_series[0].name;
      }

      // 获取菜品名称
      const itemTitle = item.querySelector('h3');
      if (!itemTitle) {
        console.log('跳过没有标题的菜品');
        continue;
      }

      const dishName = itemTitle.textContent.trim();
      console.log(`处理菜品: ${dishName}`);

      // 获取菜品描述
      const itemDesc = item.querySelector('p');
      const description = itemDesc ? itemDesc.textContent.trim() : '';

      // 获取菜品价格
      const priceElement = item.querySelector('.menuitempreview_pricevalue');
      let price = '';
      if (priceElement) {
        price = priceElement.textContent.trim().replace(/[^\d.]/g, '');
      }

      // 获取菜品图片
      const imageElement = item.querySelector('img');
      let imageUrl = '';
      if (imageElement) {
        imageUrl = imageElement.src;
      }

      // 创建菜品对象
      const dish = {
        name_en: dishName,
        name_ch: '', // 网站上可能没有中文名
        price: price,
        dishes_serice: categoryName,
        signature_dishes: 0, // 默认不是招牌菜
        image_url: imageUrl,
        detail: description,
        diches_specs: [],
      };

      // 获取菜品ID，用于模拟点击获取详情
      const itemId = itemLink
        ? itemLink.getAttribute('data-load-menu-item')
        : '';

      if (itemId) {
        console.log(`菜品ID: ${itemId}`);

        try {
          console.log(`尝试点击菜品 ${dishName} 获取详细信息`);

          // 保存当前滚动位置
          const scrollPos = window.scrollY;

          // 模拟点击菜品链接
          itemLink.click();

          // 等待弹窗加载
          await new Promise((resolve) => setTimeout(resolve, 1500));

          // 获取弹窗内容 - 使用多种可能的选择器
          const modalContent = document.querySelector(
            '#add_menu_item .menu-item-container, .modal-content .menu-item-container, .modal-body, [role="dialog"] .menu-item-container'
          );

          if (modalContent) {
            console.log(`找到菜品 ${dishName} 的弹窗内容`);
            console.log(
              '弹窗HTML结构:',
              modalContent.outerHTML.substring(0, 500) + '...'
            );

            // 尝试多种可能的选择器来寻找规格选项
            const optionSelectors = [
              '.menu-option-group',
              '.option-group',
              '.form-group',
              '.menu-options',
              '.menu-item-options',
              '.choice-group',
              '.radio-group',
              'fieldset',
            ];

            // 使用多个选择器尝试查找规格组
            let optionGroups = [];
            for (const selector of optionSelectors) {
              const groups = modalContent.querySelectorAll(selector);
              if (groups && groups.length > 0) {
                console.log(
                  `使用选择器 ${selector} 找到 ${groups.length} 个可能的规格组`
                );
                optionGroups = groups;
                break;
              }
            }

            console.log(`共找到 ${optionGroups.length} 个规格选项组`);

            if (optionGroups.length > 0) {
              // 处理每个规格选项组
              for (const group of optionGroups) {
                console.log(
                  '规格组HTML:',
                  group.outerHTML.substring(0, 300) + '...'
                );

                // 尝试多种可能的选择器来获取组标题
                const titleSelectors = [
                  '.option-group-name',
                  '.group-title',
                  '.form-group-label',
                  'legend',
                  'h3',
                  'h4',
                  'label',
                  '.control-label',
                ];

                let groupTitle = null;
                for (const selector of titleSelectors) {
                  const title = group.querySelector(selector);
                  if (title) {
                    groupTitle = title;
                    break;
                  }
                }

                const groupName = groupTitle
                  ? groupTitle.textContent.trim()
                  : 'Specifications';

                console.log(`规格组名称: ${groupName}`);

                // 检查是否是多选（通过多种方式）
                const isMultiSelect =
                  group.querySelector('input[type="checkbox"]') !== null ||
                  group.classList.contains('multiple') ||
                  group.hasAttribute('data-multiple') ||
                  group.querySelector('[multiple]') !== null;

                const specs = {
                  specs_name: groupName,
                  multi_select: isMultiSelect ? 1 : 0,
                  is_max_optins: 0,
                  max_options: 0,
                  min_options: 0,
                  specs_addition: 0,
                  default_id: 0,
                  detail: '',
                  specs_list: [],
                };

                // 尝试多种可能的选择器来获取选项
                const optionItemSelectors = [
                  '.menu-option-item',
                  '.option-item',
                  '.radio-item',
                  '.form-check',
                  '.form-radio',
                  'input[type="radio"] + label',
                  'input[type="checkbox"] + label',
                  '.custom-radio',
                  '.custom-checkbox',
                  '.choice-item',
                  '.menu-item-option',
                ];

                let options = [];
                for (const selector of optionItemSelectors) {
                  const items = group.querySelectorAll(selector);
                  if (items && items.length > 0) {
                    console.log(
                      `使用选择器 ${selector} 找到 ${items.length} 个选项`
                    );
                    options = items;
                    break;
                  }
                }

                // 如果上面的选择器没找到，尝试查找输入元素
                if (options.length === 0) {
                  const inputs = group.querySelectorAll(
                    'input[type="radio"], input[type="checkbox"]'
                  );
                  if (inputs.length > 0) {
                    console.log(`找到 ${inputs.length} 个输入元素作为选项`);
                    options = inputs;
                  }
                }

                console.log(
                  `规格组 ${groupName} 最终找到 ${options.length} 个选项`
                );

                if (options.length > 0) {
                  options.forEach((option, index) => {
                    console.log(`处理选项 ${index + 1}:`, option.outerHTML);

                    // 获取选项名称（使用多种选择器）
                    const nameSelectors = [
                      '.menu-option-item-name',
                      '.option-name',
                      '.item-name',
                      '.form-check-label',
                      'label',
                      '.radio-label',
                      '.custom-control-label',
                      'span',
                    ];

                    let optionName = null;
                    let name = '';

                    // 如果选项本身是输入元素，尝试从关联标签获取名称
                    if (option.tagName === 'INPUT') {
                      const id = option.id;
                      if (id) {
                        optionName = document.querySelector(
                          `label[for="${id}"]`
                        );
                      }
                      if (!optionName && option.parentElement) {
                        optionName =
                          option.parentElement.querySelector('label');
                      }

                      // 如果还没找到，尝试使用其value或name属性
                      if (!optionName) {
                        name =
                          option.value ||
                          option.name ||
                          'Option ' + (index + 1);
                      }
                    } else {
                      // 正常尝试各种选择器
                      for (const selector of nameSelectors) {
                        const nameEl = option.querySelector(selector);
                        if (nameEl) {
                          optionName = nameEl;
                          break;
                        }
                      }

                      // 如果找不到子元素，检查元素本身是否包含文本
                      if (!optionName && option.textContent.trim()) {
                        name = option.textContent.trim();
                      }
                    }

                    if (optionName) {
                      name = optionName.textContent.trim();
                    }

                    if (!name) {
                      console.log('选项没有名称，将使用默认名称');
                      name = 'Option ' + (index + 1);
                    }

                    console.log(`选项名称: ${name}`);

                    // 获取选项价格（使用多种选择器）
                    const priceSelectors = [
                      '.menu-option-item-price',
                      '.option-price',
                      '.item-price',
                      '.price',
                      '.additional-cost',
                      '[data-price]',
                    ];

                    let optionPrice = null;
                    let price = '0.0';

                    for (const selector of priceSelectors) {
                      const priceEl = option.querySelector(selector);
                      if (priceEl) {
                        optionPrice = priceEl;
                        break;
                      }
                    }

                    // 检查是否有价格属性
                    if (!optionPrice && option.hasAttribute('data-price')) {
                      price = option.getAttribute('data-price');
                    }

                    if (optionPrice) {
                      const priceText = optionPrice.textContent.trim();
                      console.log(`原始价格文本: ${priceText}`);

                      // 提取价格中的数字
                      const priceMatch = priceText.match(/[\d.]+/);
                      if (priceMatch) {
                        price = priceMatch[0];
                      }
                    }

                    if (!price) price = '0.0';
                    console.log(`选项价格: ${price}`);

                    // 检查是否是默认选项（使用多种方法）
                    const isDefault =
                      option.classList.contains('selected') ||
                      option.classList.contains('default') ||
                      option.classList.contains('active') ||
                      option.hasAttribute('checked') ||
                      option.hasAttribute('selected') ||
                      option.hasAttribute('data-default') ||
                      (option.tagName === 'INPUT' && option.checked) ||
                      option.querySelector('input:checked') !== null;

                    if (isDefault) {
                      specs.default_id = index + 1;
                      console.log(`选项 ${name} 是默认选项`);
                    }

                    // 添加规格选项
                    specs.specs_list.push({
                      name: name,
                      money: price,
                      id: index + 1,
                      count: 1,
                    });
                  });

                  // 设置最大选项数
                  specs.max_options = specs.specs_list.length;

                  // 只有当找到选项时才添加规格组
                  if (specs.specs_list.length > 0) {
                    console.log(
                      `添加规格组 ${specs.specs_name} 到菜品 ${dishName}，共有 ${specs.specs_list.length} 个选项`
                    );
                    dish.diches_specs.push(specs);
                  }
                }
              }
            } else {
              // 如果没有找到规格选项组，检查是否有大小选项
              // 通常体现为多个"Add to Cart"按钮，每个对应不同大小和价格
              const sizeOptions = modalContent.querySelectorAll(
                '.menu-item-size-price'
              );

              if (sizeOptions.length > 1) {
                console.log(`找到 ${sizeOptions.length} 个大小选项`);

                const sizeSpecs = {
                  specs_name: 'Size',
                  multi_select: 0,
                  is_max_optins: 0,
                  max_options: sizeOptions.length,
                  min_options: 1,
                  specs_addition: 0,
                  default_id: 1, // 默认第一个
                  detail: '',
                  specs_list: [],
                };

                let basePrice = 0;

                sizeOptions.forEach((option, index) => {
                  const sizeName = option.querySelector('.menu-item-size');
                  const sizePrice = option.querySelector('.menu-item-price');

                  if (sizeName && sizePrice) {
                    const name = sizeName.textContent.trim();
                    const price = sizePrice.textContent
                      .trim()
                      .replace(/[^\d.]/g, '');

                    // 第一个价格作为基础价格
                    if (index === 0) {
                      basePrice = parseFloat(price);
                      // 更新菜品基础价格
                      dish.price = price;

                      sizeSpecs.specs_list.push({
                        name: name,
                        money: '0.0', // 基础价格，差价为0
                        id: index + 1,
                        count: 1,
                      });
                    } else {
                      // 计算价格差
                      const currentPrice = parseFloat(price);
                      const priceDiff = (currentPrice - basePrice).toFixed(1);

                      sizeSpecs.specs_list.push({
                        name: name,
                        money: priceDiff,
                        id: index + 1,
                        count: 1,
                      });
                    }
                  }
                });

                if (sizeSpecs.specs_list.length > 0) {
                  dish.diches_specs.push(sizeSpecs);
                }
              }
            }
          } else {
            console.log(`未找到菜品 ${dishName} 的弹窗内容`);
          }

          // 关闭弹窗
          const closeButton =
            document.querySelector('#add_menu_item .close') ||
            document.querySelector('#add_menu_item [data-bs-dismiss="modal"]');

          if (closeButton) {
            console.log('点击关闭按钮');
            closeButton.click();
          } else {
            // 如果没有找到关闭按钮，尝试点击模态框背景
            console.log('尝试点击模态框背景关闭');
            const backdrop = document.querySelector('.modal-backdrop');
            if (backdrop) {
              backdrop.click();
            }
          }

          // 等待弹窗关闭
          await new Promise((resolve) => setTimeout(resolve, 500));

          // 恢复滚动位置
          window.scrollTo(0, scrollPos);
        } catch (error) {
          console.error(`获取菜品 ${dishName} 详情时出错:`, error);
        }
      }

      // 如果价格文本中包含价格范围 (如 "$8.95 - $10.95")
      if (priceElement && priceElement.textContent.includes('-')) {
        const priceText = priceElement.textContent;
        const priceRange = priceText.match(/\$(\d+\.\d+)\s*-\s*\$(\d+\.\d+)/);

        if (priceRange) {
          console.log(`菜品 ${dishName} 有价格区间: ${priceText}`);

          const smallPrice = priceRange[1];
          const largePrice = priceRange[2];
          const priceDiff = (
            parseFloat(largePrice) - parseFloat(smallPrice)
          ).toFixed(1);

          // 只有在没有其他规格的情况下才添加大小规格
          if (dish.diches_specs.length === 0) {
            // 创建大小规格
            const sizeSpecs = {
              specs_name: 'Size',
              multi_select: 0,
              is_max_optins: 0,
              max_options: 2,
              min_options: 1,
              specs_addition: 0,
              default_id: 1,
              detail: '',
              specs_list: [
                {
                  name: 'Small',
                  money: '0.0',
                  id: 1,
                  count: 1,
                },
                {
                  name: 'Large',
                  money: priceDiff,
                  id: 2,
                  count: 1,
                },
              ],
            };

            dish.diches_specs.push(sizeSpecs);
            dish.price = smallPrice; // 使用小份的价格作为基础价格
          }
        }
      }

      // 将菜品添加到结果中
      result.dishes_list.push(dish);
      console.log(`成功添加菜品: ${dishName}`);
    }

    console.log(`成功添加 ${result.dishes_list.length} 个菜品`);

    // 如果没有找到任何菜系或菜品，尝试从页面内容推断
    if (result.dishes_series.length === 0 || result.dishes_list.length === 0) {
      console.log('未找到菜系或菜品，尝试从页面内容推断');

      // 尝试从页面文本中提取菜系和菜品
      const pageText = document.body.textContent;

      // 常见的中餐菜系
      const commonCategories = [
        'Appetizers',
        'Soup',
        'Noodles',
        'Fried Rice',
        'Seafood',
        'Beef',
        'Chicken',
        'Pork',
        'Tofu & Vegetables',
        'Egg Foo Young',
        "Chef's Specials",
        'Thai Curry',
        'Family Dinners',
        'Sides',
        'Dessert',
        'Soft Drinks',
      ];

      // 检查页面中是否包含这些菜系
      let categoryCount = 0;
      for (const category of commonCategories) {
        if (pageText.includes(category)) {
          console.log(`从页面内容中找到菜系: ${category}`);

          // 添加到菜系列表，如果还没有
          if (!result.dishes_series.some((cat) => cat.name === category)) {
            result.dishes_series.push({
              index: categoryCount++,
              name: category,
              description: '',
              monday: '',
              tuesday: '',
              wednesday: '',
              thursday: '',
              friday: '',
              saturday: '',
              sunday: '',
            });
          }
        }
      }
    }

    return result;
  } catch (error) {
    console.error('抓取过程中发生错误:', error);
    throw error;
  }
}

// 辅助函数：将12小时制转换为24小时制
function convertTo24HourFormat(timeStr) {
  const [time, modifier] = timeStr.split(/([ap]m)/i);
  let [hours, minutes] = time.split(':');

  hours = parseInt(hours, 10);

  if (modifier.toLowerCase() === 'pm' && hours < 12) {
    hours += 12;
  } else if (modifier.toLowerCase() === 'am' && hours === 12) {
    hours = 0;
  }

  return `${hours.toString().padStart(2, '0')}:${minutes || '00'}`;
}
